.TH std::underlying_type 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::underlying_type \- std::underlying_type

.SH Synopsis
   Defined in header <type_traits>
   template< class T >              \fI(since C++11)\fP
   struct underlying_type;

   If T is a complete enumeration \fI(enum)\fP type, provides a member typedef type that
   names the underlying type of T.

   Otherwise, the behavior is undefined.                                  \fI(until C++20)\fP
   Otherwise, if T is not an enumeration type, there is no member type.
   Otherwise (T is an incomplete enumeration type), the program is        \fI(since C++20)\fP
   ill-formed.

   If the program adds specializations for std::underlying_type, the behavior is
   undefined.

.SH Member types

   Name Definition
   type the underlying type of T

.SH Helper types

   template< class T >                                           \fI(since C++14)\fP
   using underlying_type_t = typename underlying_type<T>::type;

.SH Notes

   Each enumeration type has an underlying type, which can be

    1. Specified explicitly (both scoped and unscoped enumerations);
    2. Omitted, in which case it is int for scoped enumerations or an
       implementation-defined integral type capable of representing all values of the
       enum (for unscoped enumerations).

.SH Example


// Run this code

 #include <iostream>
 #include <type_traits>

 enum e1 {};
 enum class e2 {};
 enum class e3 : unsigned {};
 enum class e4 : int {};

 int main()
 {
     constexpr bool e1_t = std::is_same_v<std::underlying_type_t<e1>, int>;
     constexpr bool e2_t = std::is_same_v<std::underlying_type_t<e2>, int>;
     constexpr bool e3_t = std::is_same_v<std::underlying_type_t<e3>, int>;
     constexpr bool e4_t = std::is_same_v<std::underlying_type_t<e4>, int>;

     std::cout
         << "underlying type for 'e1' is " << (e1_t ? "int" : "non-int") << '\\n'
         << "underlying type for 'e2' is " << (e2_t ? "int" : "non-int") << '\\n'
         << "underlying type for 'e3' is " << (e3_t ? "int" : "non-int") << '\\n'
         << "underlying type for 'e4' is " << (e4_t ? "int" : "non-int") << '\\n';
 }

.SH Possible output:

 underlying type for 'e1' is non-int
 underlying type for 'e2' is int
 underlying type for 'e3' is non-int
 underlying type for 'e4' is int

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to         Behavior as published              Correct behavior
   LWG 2396 C++11      incomplete enumeration types were      complete enumeration type
                       allowed                                required

.SH See also

   is_enum        checks if a type is an enumeration type
   \fI(C++11)\fP        \fI(class template)\fP
   is_scoped_enum checks if a type is a scoped enumeration type
   (C++23)        \fI(class template)\fP
   to_underlying  converts an enumeration to its underlying type
   (C++23)        \fI(function template)\fP
